package com.resourcestore.utils;
import java.util.*;
import java.text.SimpleDateFormat;
import java.text.DecimalFormat;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.ActionContext;
import com.resourcestore.model.CourseTeaClassFK;

public class CommonUtil {

	protected static Logger logger = Logger.getLogger("RequestResponseUtil");

	/**
	 * 通过所访问的URL（通常是一个.do类型的访问地址），得到真正需要访问的类和方法
	 * 
	 * @param requestURL
	 *            所要访问的URL地址
	 * @return
	 */
	public static Map<String, String> getAccessClassAndMethod(String requestURL) {

		requestURL = requestURL.replace("/", "");// 把url中的/去掉
		requestURL = requestURL.replace(".do", "");// 把url中的.do去掉

		String[] splitRequestURL = requestURL.split("_");// 将url分割成为两部分，前一部分是类名，
															// 后一部分是方法名

		Map<String, String> result = new HashMap<String, String>();

		result.put("className", splitRequestURL[0]);
		result.put("methodName", splitRequestURL[1]);

		return result;
	}

	/**
	 * 动态调用类中方法，并将结果返回
	 * 
	 * @param classAndMethodMap
	 */
	public static void dynamicCallClassAndMethod(Map<Integer, String> classAndMethodMap) {
		String className = classAndMethodMap.get(0);
		String methodName = classAndMethodMap.get(1);

		try {
			Class theCalledClass = Class.forName(className);
			Method theCalledMethod = theCalledClass.getMethod(methodName, null);

		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 判断字符串是否为数字，是数字返回true，否则返回false
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isLong(String str) {
		return str.matches("^[\\+-]?[\\d]+$");
	}

	/**
	 * 根据returnPage的参数进行解析，并得到真正的returnPage
	 * 一般的returnPage结构如：user_insert.jsp--pageNo=1--userType=2，解析后结构变为：
	 * user_insert.jsp?pageNo=1&userType=2
	 * 
	 * @param returnPage
	 * @return
	 */
	public static String getReturnPage(String returnPage, HttpSession session) {
		if (isLong(returnPage)) {// 是数字
			List<String> list = (List<String>) session.getAttribute("URLList");
			int whichRecord = list.size() - Integer.parseInt(returnPage);
			if (whichRecord < 0) {
				whichRecord = list.size() - 1;
			}
			return list.get(whichRecord);// 如果returnPage=-1，代表返回上次访问的页面，
											// 即取URLList的最后一项记录
											// ，其他如-2，-3等依次类推，未处理如果填值小于-20的情况
		} else {// 不是数字
			returnPage = returnPage.replaceFirst("--", "?");// 将第一个--换为?号
			returnPage = returnPage.replace("--", "&");// 将后面所有的--换为&号
		}
		return returnPage;
	}

	/**
	 * 装载已访问过的URL列表，最多装载20条记录
	 * 
	 * @return
	 */
	public static void addSourceURLToSession(String lastURL) {
		Map session = ActionContext.getContext().getSession();
		List<String> urlList = (List<String>) session.get("urlList");
		if (null == urlList) {
			urlList = new ArrayList<String>();
		}
		urlList.add(lastURL);// 将最近访问的URL放到list的结尾处

		if (urlList.size() > 10) {
			urlList.remove(0);// 当list的大小超过10时，去掉第一条数据
		}
		session.put("urlList", urlList);
	}

	//
	// /**
	// *
	// * 通过类名和方法名，动态调用该类中的该方法
	// *
	// * @param className
	// * 类名
	// * @param methodName
	// * 方法名
	// * @param params
	// * 参数对象
	// * @return 所有的方法，都返回String，默认返回""(如果被调用的方法无需返回数据时，则本方法返回"")
	// */
	// public static String callMethod(String className, String methodName,
	// Object params) {
	// String result = "";
	// try {
	// Class certainClass = Class.forName(className);
	// Method certainMethod = certainClass.getMethod(methodName,
	// certainClass);
	// String methodReturn = (String) certainMethod.invoke(certainClass
	// .newInstance(), params);
	// if (null == methodReturn || "".equals(methodReturn)) {
	// return result;
	// } else
	// return methodReturn;
	// } catch (ClassNotFoundException e) {
	// logger.error("找不到该类：" + className + "---" + e);
	// } catch (SecurityException e) {
	// logger.error("安全问题" + "---" + e);
	// } catch (NoSuchMethodException e) {
	// logger.error("找不到该方法：" + methodName + "---" + e);
	// } catch (IllegalArgumentException e) {
	// logger.error(e);
	// } catch (IllegalAccessException e) {
	// logger.error(e);
	// } catch (InvocationTargetException e) {
	// logger.error(e);
	// } catch (InstantiationException e) {
	// logger.error(e);
	// }
	// return result;
	// }

	/**
	 * 
	 * 通过类名和方法名，动态调用该类中的该方法
	 * 
	 * @param className
	 *            类名
	 * @param methodName
	 *            方法名
	 * @return 所有的方法，都返回Object，默认返回""(如果被调用的方法无需返回数据时，则本方法返回"")
	 */
	public static Object callMethod(String className, String methodName) {
		try {
			Class certainClass = Class.forName(className);
			Method certainMethod = certainClass.getMethod(methodName, certainClass);
			Object methodReturn = (String) certainMethod.invoke(certainClass.newInstance());
			if (null == methodReturn || "".equals(methodReturn)) {
				return "";
			} else
				return methodReturn;
		} catch (ClassNotFoundException e) {
			logger.error("找不到该类：" + className + "---" + e);
		} catch (SecurityException e) {
			logger.error("安全问题" + "---" + e);
		} catch (NoSuchMethodException e) {
			logger.error("找不到该方法：" + methodName + "---" + e);
		} catch (IllegalArgumentException e) {
			logger.error(e);
		} catch (IllegalAccessException e) {
			logger.error(e);
		} catch (InvocationTargetException e) {
			logger.error(e);
		} catch (InstantiationException e) {
			logger.error(e);
		}
		return "";
	}

	/**
	 * 获取服务器端系统时间
	 * 
	 * @return
	 * @throws ParseException
	 */
	public static Date getSysTime() throws ParseException {
		return new Date();
	}

	/**
	 * 将map的String数组类型的value转化为String类型，并返回该map
	 * 
	 * @param map
	 * @return
	 */
	public static Map<String, String> changeMapValueToString(Map<String, String[]> map) {
		Map<String, String> returnMap = new HashMap<String, String>();

		for (Map.Entry<String, String[]> entry : map.entrySet()) {
			String key = entry.getKey();
			String[] value = entry.getValue();

			StringBuffer strValue = new StringBuffer();
			if (value.length < 1) {
				strValue.append("");
			} else if (value.length == 1) {
				strValue.append(value[0]);
			} else {
				// 如果value数组长度大于1，那么肯定是从页面提交了复选框进来，将value数组的每一项后面加上,号并组合成一个字符串
				// 如：原来的value数组为{"aaa","bbb","ccc"}，修改后变成"aaa,bbb,ccc"
				int i = 0;
				for (; i < value.length - 1; i++) {
					strValue.append(value[i]);
					strValue.append(",");
				}
				strValue.append(value[i]);
			}

			returnMap.put(key, strValue.toString());
		}

		return returnMap;
	}

	/**
	 * 将类转化为map
	 * 
	 * @param <T>
	 *            待转化的类
	 * @param t
	 * @return
	 */
	public static Map changeBeanIntoMap(Object t) {
		Map<String, Object> map = new HashMap<String, Object>();

		Class cls = t.getClass();

		Method[] mtd = cls.getDeclaredMethods();
		for (int i = 0; i < mtd.length; i++) {
			String mtdName = mtd[i].getName();
			if (mtdName.startsWith("get")) {
				// 去掉get并且将get后面的第一个字母变为小写，比如原来为getNumber，转换后变为number
				String fieldName = mtdName.substring(3, 4).toLowerCase() + mtdName.substring(4);
				try {
					map.put(fieldName, cls.getMethod(mtdName).invoke(t, null));
				} catch (IllegalArgumentException e) {
					logger.error(e);
				} catch (SecurityException e) {
					logger.error(e);
				} catch (IllegalAccessException e) {
					logger.error(e);
				} catch (InvocationTargetException e) {
					logger.error(e);
				} catch (NoSuchMethodException e) {
					logger.error(e);
				}
			}
		}

		return map;
	}

	/**
	 * 判断对象是否为空
	 * 
	 * @param obj
	 * @return
	 */
	public static boolean isNotNullOrNotEqualsEmpty(Object obj) {

		if (null == obj) {
			return false;
		} else if (obj instanceof Collection) {
			if (((Collection) obj).size() == 0) {
				return false;
			}
		} else if (obj instanceof String) {
			if ("".equals(obj.toString())) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 从一个字符串进行分割获得List集合（该集合是Integer类型）
	 * 
	 * @param str
	 *            带分割的字符串，假设是1-2-3
	 * @param splitStr
	 *            分割符，即上例中的-，不支持正则表达式
	 * @return
	 */
	public static List<Integer> listFromSplit(String str, String splitStr) {
		List<Integer> quesTypeList = new ArrayList<Integer>();
		if (isNotNullOrNotEqualsEmpty(str)) {
			int lastIndex = 0;
			while (str.indexOf(splitStr, lastIndex) != -1) {

				int thisIndex = str.indexOf(splitStr, lastIndex);

				quesTypeList.add(Integer.parseInt(str.substring(lastIndex, thisIndex)));
				lastIndex = thisIndex + splitStr.length();
			}
			quesTypeList.add(Integer.parseInt(str.substring(lastIndex, str.length())));
		}
		return quesTypeList;
	}

	private static String changeStrToGetMethodNames(String str) {

		if (str == null || str.equals("") || str.equals(" "))
			return null;

		int strLength = str.length();

		char firstChar = str.toCharArray()[0];
		String upstr = String.valueOf(firstChar).toUpperCase();

		return "get" + upstr + str.substring(1);
	}

	/**
	 * 返回空集合列表
	 * 
	 * @return
	 */
	public List emptyList() {
		return new ArrayList();
	}

	/**
	 * 从整型数组中删除元素
	 * 
	 * @param arr
	 * @param itemDel
	 * @return
	 */
	public static boolean deleteItemInArray(int[] arr, int itemDel) {
		if (null == arr || arr.length == 0 || itemDel < 0 || itemDel >= arr.length)
			return false;
		if (arr.length == 1) {
			arr[0] = 0;
			return true;
		}
		for (int i = itemDel; i < arr.length - 1; ++i) {
			arr[i] = arr[i + 1];
		}
		arr[arr.length - 1] = 0;
		return true;
	}
	
	
	/**
	 * 处理url中的端口问题
	 * @param request
	 * @return
	 */
	public static String urlPortDistinguish(HttpServletRequest request){
		// 如果是本机，本处是http://localhost:80/webcourse
		String basePath = request.getScheme() + "://"
				+ request.getServerName();
		if (80 != request.getServerPort()) {
			basePath += ":" + request.getServerPort();
		}
		basePath += request.getContextPath() + "/";
		return basePath;
	}
	/**
	 * 长整型的数字转换为字符型时间
	 */
	public static String longToTime(long time){
		String timeResult;
		long h,m,s;
		h=0;m=0;s=0;
		if(time>=3600)
			h=time/3600;
		else if((time%3600)>=60)
			m=(time%3600)/60;
		else s=time%60;	
		timeResult=String.valueOf(h)+"小时"+String.valueOf(m)+"分"+String.valueOf(s)+"秒";						
		return timeResult;
	}

    //转换时间格式
	public String CovertDateTime(Date datetime){
		SimpleDateFormat datetimeByFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String coveredDateTime = datetimeByFormat.format(datetime);
		return coveredDateTime;
	}
	
	//获取当前系统日期时间
	public String GetDatetime() {
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String system_time = sdf.format(cal.getTime());
		return system_time;
	}
	
	//获取当前系统日期时间(yyyyMMdd)
	public String GetDatetimeYMD(Date datetime) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		String system_time = sdf.format(datetime);
		return system_time;
	}
	
	 /**
	  * 过滤<, >,\n 字符的方法�?
	  * @param input �?��过滤的字�?	  * @return 完成过滤以后的字符串
	  */
	 public static String filterHtml(String input) {
	  if (input == null) {
	   return null;
	  }
	  if (input.length() == 0) {
	   return input;
	  }
	  input = input.replaceAll("&", "&amp;");
	  input = input.replaceAll("<", "&lt;");
	  input = input.replaceAll(">", "&gt;");
	  input = input.replaceAll(" ", "&nbsp;");
	  input = input.replaceAll("'", "&#39;");
	  input = input.replaceAll("\"", "&quot;");
	  return input.replaceAll("\n", "<br>");
	 }
	 
	 //格式化double型数值，保留2位小数
	 public static String formatDouble(double number){
		 DecimalFormat df=new DecimalFormat("#0.00"); 
		 String new_number = df.format(number); 
		 return new_number;
	 }
	 
	 //产生18位随机数
	 public String ChanshengChar18() {
		    /**
		     * 初始化cal  cal用来得到系统时间
		     */
		    Calendar cal = Calendar.getInstance();
		    /**
		     * 设置时间格式
		     */
		    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		    String xitongshijian = sdf.format(cal.getTime());
		    String suijishu = "";
		    /**
		     * 产生随机数方法，  随机数类  java.util.Random
		     * r.nextFloat()  产生一个大于0小于1的小数（float类型）
		     */
		    Random r = new Random();
		    int i = (int) Math.floor(r.nextFloat() * 10000);
		    /**
		     * 如果产生的随机数小于1000，即小于4位数，该数自加1000
		     */
		    if (i < 1000) {
		      i += 1000;
		    }
		    suijishu = xitongshijian + i;
		    return suijishu;
		  }
	 
	 /*
	  * 将每组十进制字串转换为字符串
	  */
	 /*
	 public String turnOnePeopleString(String one){
		 
		 String turnOne = null;
		 
		 String cardNum = one.substring(6,39);//获取卡号
		 String year = one.substring(6,39);//获取年
		 String month = one.substring(6,39);//获取月
		 String day = one.substring(6,39);//获取日
		 
		 return turnOne;
	 }
	 */


	    /**
	     * 将数据库中时间格式化
	     * 
	     * @return
	     * @throws ParseException
	     */
	    public static String getSysTimeFormatString(long num) throws ParseException {
	        String temp = String.valueOf(num);
	        String nowDateString = temp.substring(0, 4) + "-" + temp.substring(4, 6) + "-" + temp.substring(6, 8) + " "
	                               + temp.substring(8, 10) + ":" + temp.substring(10, 12) + ":" + temp.substring(12, 14);
	        return nowDateString;
	    }
	    
	    /**
	     * 获取服务器端系统时间，并格式化
	     * 
	     * @return
	     * @throws ParseException
	     */
	    public static long getSysTimeFormatNum() throws ParseException {
	        Date systimeDate = getSysTime();
	        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
	        long nowDateNum = Long.valueOf(dateFormat.format(systimeDate));
	        return nowDateNum;
	    }
	    /**
	     * 拆分字符串
	     * @param str
	     * @param sign
	     * @return
	     */
	    public static String[] split(String str, String sign) {
	    	  String[] strData = null;
	    	  StringTokenizer st1 = new StringTokenizer(str, sign);
	    	  strData = new String[st1.countTokens()];
	    	  int i = 0;
	    	  while (st1.hasMoreTokens()) {
	    	   strData[i] = st1.nextToken().trim();
	    	   i++;
	    	  }
	    	  return strData;
	    	 }
	    /**
	 * 清除字符串所有的空格
	 * 
	 * @param str
	 * @return
	 */
	public static String trimAll(String str) {
		StringBuilder sb = new StringBuilder();
		char c = ' ';
		for (int i = 0; i < str.length(); i++) {
			char s = str.charAt(i);
			if (s != c) {
				sb.append(s);
			}
		}
		return sb.toString();
	}
	    
	    /**
	 * 去除数组中重复元素
	 * 
	 * @param ss
	 * @return
	 */
	public static String[] distinctArray(String[] ss) {
		int len = ss.length;
		int marklen = len;
		for (int i = 0; i < len; i++) {
			for (int j = i + 1; j < len; j++) {
				if (ss[i] != null && ss[i].equals(ss[j])) {
					ss[j] = null;
					marklen = marklen - 1;
				}
			}
		}

		String[] ssStrings = new String[marklen];
		int j = 0;
		for (int i = 0; i < ss.length; i++) {
			if (ss[i] != null) {
				ssStrings[j] = ss[i];
				j = j + 1;
			}
		}
		return ssStrings;
	}
    /**
	 * 去除LIST中重复元素有序
	 * 
	 * @param ss
	 * @return
	 */
	public static void removeDuplicateWithOrder(List<CourseTeaClassFK> listCourseTeaFK) {
		Set set = new HashSet();
		List newList = new ArrayList();
		for (Iterator iter = listCourseTeaFK.iterator(); iter.hasNext();) {
			Object element = iter.next();
			if (set.add(element))
				newList.add(element);
		}
		listCourseTeaFK.clear();
		listCourseTeaFK.addAll(newList);
	}  
    /**
	 * 去除LIST中重复元素 无序
	 * 
	 * @param ss
	 * @return
	 */
	public static void removeDuplicate(List<CourseTeaClassFK> listCourseTeaFK) {
		HashSet h = new HashSet(listCourseTeaFK);
		listCourseTeaFK.clear();
		listCourseTeaFK.addAll(h);
	}    
	
	/**  
	 * 删除单个文件  
	 * @param   sPath    被删除文件的文件名  
	 * @return 单个文件删除成功返回true，否则返回false  
	 */  
	public static boolean deleteFile(String sPath) {   
	    boolean flag = false;   
	    File file = new File(sPath);   
	    // 路径为文件且不为空则进行删除   
	    if (file.isFile() && file.exists()) {   
	        file.delete();   
	        flag = true;   
	    }   
	    return flag;   
	}  

}
